package com.pai4j.user.controller;

import com.pai4j.common.bean.PAIPageResponseBeanUtil;
import com.pai4j.common.bean.PAIResponseBean;
import com.pai4j.common.bean.PAIResponseBeanUtil;
import com.pai4j.domain.vo.request.CreateGroupRequestVO;
import com.pai4j.domain.vo.response.AccountRelationResponseVO;
import com.pai4j.domain.vo.response.UserBaseResponseInfoVO;
import com.pai4j.domain.vo.response.WaitConfirmUserResponseVO;
import com.pai4j.remote.user.AccountRelationClient;
import com.pai4j.user.service.relation.AccountRelationService;
import com.pai4j.user.service.relation.FriendFollowService;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * 账号关系服务
 */
@RestController
public class AccountRelationController implements AccountRelationClient {
    
    
    private static final Log log = LogFactory.getLog(AccountRelationController.class);
    @Autowired
    private AccountRelationService accountRelationService;
    @Autowired
    private FriendFollowService friendFollowService;


    /**
     * 添加关注
     *
     * @param sourceAccount: 关注人：发起关注请求的账号
     * @param targetAccount：被关注人：被关注账号
     * @return
     */
    @Override
    public PAIResponseBean<Boolean> subscribe(@PathVariable String sourceAccount,
                                              @PathVariable String targetAccount) {

        return PAIResponseBeanUtil.success(accountRelationService.subscribe(sourceAccount, targetAccount));
    }

    /**
     * 取消关注
     *
     * @param sourceAccount
     * @param targetAccount
     * @return
     */
    @Override
    public PAIResponseBean<Boolean> unsubscribe(@PathVariable String sourceAccount,
                                                @PathVariable String targetAccount) {

        return PAIResponseBeanUtil.success(accountRelationService.unsubscribe(sourceAccount, targetAccount));
    }


    /**
     * 确认关注（通过好友申请）
     * 备注为可选参数，如果提供备注则发送互动消息通知申请人
     *
     * @param confirmAccount 确认账号
     * @param relationId 关系ID
     * @param remark 通过备注（可选）
     * @return
     */
    @Override
    public PAIResponseBean<Boolean> confirmSubscribe(@RequestParam("confirmAccount") String confirmAccount,
                                                     @RequestParam("relationId") Long relationId,
                                                     @RequestParam(value = "remark", required = false) String remark) {

        return PAIResponseBeanUtil.success(accountRelationService.confirmSubscribe(confirmAccount, relationId, remark));
    }

    /**
     * 拒绝关注（拒绝好友申请）
     * 拒绝理由为可选参数，如果提供理由则发送互动消息通知申请人
     *
     * @param rejectAccount 拒绝账号
     * @param relationId 关系ID
     * @param remark 拒绝理由（可选）
     * @return
     */
    @Override
    public PAIResponseBean<Boolean> rejectSubscribe(@RequestParam("rejectAccount") String rejectAccount,
                                                    @RequestParam("relationId") Long relationId,
                                                    @RequestParam(value = "remark", required = false) String remark) {

        return PAIResponseBeanUtil.success(accountRelationService.rejectSubscribe(rejectAccount, relationId, remark));
    }

    /**
     * 分页查询关注列表
     *
     * @param account
     * @param type
     * @param pageNo
     * @param pageSize
     * @return
     */
    @Override
    public PAIPageResponseBeanUtil<UserBaseResponseInfoVO> pageRelations(String account, Integer type, Integer pageNo, Integer pageSize) {

        return accountRelationService.pageRelations(account, type, pageNo, pageSize);
    }

    /**
     * 获取关注列表
     *
     * @param account
     * @return
     */
    @Override
    public PAIResponseBean<AccountRelationResponseVO> listRelations(@PathVariable String account) {

        return PAIResponseBeanUtil.success(accountRelationService.listRelations(account));
    }

    /**
     * 获取待确认关注列表
     *
     * @param account
     * @return
     */
    @Override
    public PAIResponseBean<List<WaitConfirmUserResponseVO>> listWaitConformUsers(@PathVariable String account) {

        return PAIResponseBeanUtil.success(accountRelationService.listWaitConformUsers(account));
    }

    /**
     * 创建群聊
     *
     * @param createGroupRequest
     * @return
     */
    @Override
    public PAIResponseBean<String> createChatGroup(@RequestBody CreateGroupRequestVO createGroupRequest) {

        return PAIResponseBeanUtil.success(accountRelationService.createChatGroup(createGroupRequest));
    }

    /**
     * 普通关注（直接生效，无需确认）
     *
     * @param sourceAccount 关注者账号
     * @param targetAccount 被关注者账号
     * @return
     */
    @Override
    public PAIResponseBean<Boolean> follow(@PathVariable String sourceAccount,
                                          @PathVariable String targetAccount) {
        // 仅写入friend表，并构建相关缓存与互动消息
        return PAIResponseBeanUtil.success(friendFollowService.follow(sourceAccount, targetAccount));
    }

    /**
     * 取关（仅friend表）
     */
    @Override
    public PAIResponseBean<Boolean> unfollow(@PathVariable String sourceAccount,
                                             @PathVariable String targetAccount) {
        return PAIResponseBeanUtil.success(friendFollowService.unfollow(sourceAccount, targetAccount));
    }

    /**
     * 是否已关注（仅friend表）
     */
    @Override
    public PAIResponseBean<Boolean> isFollowing(@PathVariable String sourceAccount,
                                                @PathVariable String targetAccount) {
        return PAIResponseBeanUtil.success(friendFollowService.isFollowing(sourceAccount, targetAccount));
    }

    /**
     * 添加好友申请（需要对方确认）
     *
     * @param sourceAccount 申请者账号
     * @param targetAccount 被申请者账号
     * @return
     */
    @Override
    public PAIResponseBean<Boolean> addFriend(@PathVariable String sourceAccount,
                                             @PathVariable String targetAccount) {
        return PAIResponseBeanUtil.success(accountRelationService.addFriend(sourceAccount, targetAccount));
    }

    /**
     * 添加好友申请（支持推荐人信息，用于推荐卡片场景）
     *
     * @param sourceAccount 申请者账号
     * @param targetAccount 被申请者账号
     * @param recommenderAccount 推荐人账号（可选）
     * @return
     */
    @Override
    public PAIResponseBean<Boolean> addFriendWithRecommender(@PathVariable String sourceAccount,
                                                              @PathVariable String targetAccount,
                                                              @RequestParam(value = "recommenderAccount", required = false) String recommenderAccount) {
      log.info("添加好友申请（带推荐人）：sourceAccount={}, targetAccount={}, recommenderAccount={}"
      );
        return PAIResponseBeanUtil.success(accountRelationService.addFriendWithRecommender(sourceAccount, targetAccount, recommenderAccount));
    }

    /**
     * 加入群聊（语义包装）
     *
     * @param userAccount 用户账号
     * @param groupId 群账号
     * @return 是否成功
     */
    @Override
    public PAIResponseBean<Boolean> joinGroup(@PathVariable String userAccount,
                                             @PathVariable String groupId) {
        return PAIResponseBeanUtil.success(accountRelationService.joinGroup(userAccount, groupId));
    }

    /**
     * 退出群聊（语义包装）
     *
     * @param userAccount 用户账号
     * @param groupId 群账号
     * @return 是否成功
     */
    @Override
    public PAIResponseBean<Boolean> leaveGroup(@PathVariable String userAccount,
                                              @PathVariable String groupId) {
        return PAIResponseBeanUtil.success(accountRelationService.leaveGroup(userAccount, groupId));
    }

    /**
     * 获取用户的粉丝数量（基于friend表，不再依赖account_relation表）
     *
     * @param account 用户账号
     * @param relationType 关系类型（如果是用户对用户关系，从friend表查询；其他类型从account_relation表查询）
     * @return 粉丝数量
     */
    @Override
    public PAIResponseBean<Long> getFollowersCount(@PathVariable String account,
                                                  @PathVariable Integer relationType) {
        return PAIResponseBeanUtil.success(accountRelationService.getFollowersCount(account, relationType));
    }

    /**
     * 获取用户的关注数量（基于friend表，不再依赖account_relation表）
     *
     * @param account 用户账号
     * @param relationType 关系类型（如果是用户对用户关系，从friend表查询；其他类型从account_relation表查询）
     * @return 关注数量
     */
    @Override
    public PAIResponseBean<Long> getFollowingCount(@PathVariable String account,
                                                  @PathVariable Integer relationType) {
        return PAIResponseBeanUtil.success(accountRelationService.getFollowingCount(account, relationType));
    }

    /**
     * 获取用户的粉丝数量（默认用户对用户关系，基于friend表）
     *
     * @param account 用户账号
     * @return 粉丝数量
     */
    @Override
    public PAIResponseBean<Long> getUserFollowersCount(@PathVariable String account) {
        return PAIResponseBeanUtil.success(friendFollowService.getFollowersCount(account));
    }

    /**
     * 获取用户的关注数量（默认用户对用户关系，基于friend表）
     *
     * @param account 用户账号
     * @return 关注数量
     */
    @Override
    public PAIResponseBean<Long> getUserFollowingCount(@PathVariable String account) {
        return PAIResponseBeanUtil.success(friendFollowService.getFollowingCount(account));
    }
}
